 |
GemaCoreLib
The GeMA Core library
|
Loading...
Searching...
No Matches
|
GemaCoreLib
The GeMA Core library
|
Base interface class for Mesh type plugins. More...
#include <gmMesh.h>
Signals | |
| void | meshChanged () |
| Signal emmited by emitMeshChanged(). See comments on that function. | |
Public Member Functions | |
| GmMesh (GmSimulationData *simulation, QString id, QString description, const GmLogCategory &logger) | |
| Constructor. | |
| virtual | ~GmMesh () |
| Virtual destructor. | |
| virtual const char * | pluginCategory () const |
| Returns the plugin category. | |
| virtual bool | hasCapability (QString capabilityName) const =0 |
| This function should return true or false to indicate whether the mesh implementation supports the requested capability or not. Capabilities are refered by string names in order to enable derived interfaces to extend the available capabilities that can be queried. | |
| virtual bool | useDualVectors () const =0 |
| Returns true if the mesh data is stored in a "dual" vector, instead of a single one. | |
| virtual void | pushProxy (lua_State *L, const GmLogCategory &logger)=0 |
| Pushes a proxy object for the current mesh onto the Lua stack. | |
| virtual GmValueInfo * | nodeCoordInfo () const =0 |
| Returns metadata with information about node coordinates. | |
| virtual GmValueAccessor * | nodeCoordAccessor (Unit desiredUnit, const GmLogCategory &logger) const =0 |
| Returns an accessor object used to access node coordinates. | |
| virtual int | numNodes () const =0 |
| Returns the number of nodes in the mesh. | |
| virtual int | numGhostNodes () const |
| Returns the number of ghost nodes in the mesh. | |
| int | totalNumNodes () const |
| Returns the total number of nodes in the mesh, including normal nodes & ghost nodes. | |
| virtual int | numGlobalNodes () const |
| When working with partitioned meshes, returns the number of nodes in the global mesh, before partitioning. | |
| virtual int | numGlobalGhostNodes () const |
| When working with partitioned meshes, returns the number of ghost nodes in the global mesh, before partitioning. | |
| int | totalNumGlobalNodes () const |
| Returns the total number of nodes in the mesh, including normal nodes & ghost nodes. | |
| int | toLinearGhostIndex (int nodeIndex) const |
| If nodeIndex is a value with its high bit set, returns the index (high bit cleared) | |
| int | toLocalGhostIndex (int nodeIndex) const |
| Given a global ghost index (a value >= numNodes() and < totalNumNodes()), returns a zero based version of the index. If index is a 'geometry index' (nodeIndex < numNodes()), returns a negative value. | |
| virtual const QMap< QString, GmNodeSet * > & | nodeSets () const =0 |
| Returns a map of node sets registered within the mesh. Each entry in the returned map contains a group of nodes, indexed by group name. | |
| QStringList | nodeValueIds (int filter=-1) const |
| Returns a list with the id names for every attribute or state var associated with mesh nodes, depending on the filter parameter. No special order is enforced. If filter is -1, includes both of them, first state vars and then node attributes since that is the order used by printing routines. | |
| virtual GmValueInfo * | nodeValueInfo (QString id, int filter=-1) const |
| Returns the metadata describing the values (attribute / state var) associated with the value id. | |
| virtual GmValueAccessor * | nodeValueAccessor (QString id, Unit desiredUnit, const GmLogCategory &logger) const |
| Creates an accessor object for the values (attribute / state var) associated with the value id. | |
| virtual GmValueAccessor * | nodeValueAccessor (QString id, int snum, bool locked, Unit desiredUnit, const GmLogCategory &logger) const |
| Overloads nodeValueAccessor(QString, Unit, ...) to return an accessor for the requested previous state of a value. | |
| virtual GmValueAccessor * | nodeStateVarAccessorFromDof (int dof, Unit desiredUnit, GmStateVar **stateVar) const |
| Creates an accessor object for the state var associated with the requested degree of freedom number. Returns NULL if the dof number is invalid or if that state var is not associated with this mesh. | |
| virtual bool | addNodeValueSet (GmValueInfo *info) |
| Creates a new value set for storing data associated with the metadata information received as a parameter. | |
| virtual void | removeNodeValueSet (QString id) |
| Removes node value set associated to the specified id. Do nothing if such node value set is not stored in the mesh. | |
| virtual bool | initNodeValueSets () |
| Initializes all the value set groups after the addition of node attributes by calls to addNodeValueSet(). MUST be called even if the mesh initially does not have any node attribute / stat var, AFTER the number of mesh nodes and ghost nodes has been correctky initialized! | |
| virtual void | beginAddingNodeAttributeSets () |
| Initializes a block where calls to addNodeValueSet() will only initialize the new attribute value set at the call to endAddingGaussAttributeSets(). See the comments at addNodeValueSet(). Only makes sense after mesh initialization. | |
| virtual bool | endAddingNodeAttributeSets () |
| Ends the block started by the call to beginAddingGaussAttributeSets(), initializing all the value sets that where added in between. See the comments at addNodeValueSet(). Returns false in case of errors. | |
| virtual void | clearNodeValueSets () |
| Removes every valueSet stored in the mesh (attributes and state variables). Handy for plugins to cleanup on errors. | |
| virtual void | clearNodeValueSetsData () |
| An auxiliary function used to remove all data from every valueSet stored in the mesh (the value sets themselves remain). | |
| virtual bool | saveState (GmValueSet::SaveStateMode mode, const GmLogCategory &logger) |
| Simmilar to saveNodeValueState(), saves the current state of all values that support state saving. See saveNodeValueState() for more details. | |
| virtual bool | saveNodeValueState (QString id, GmValueSet::SaveStateMode mode, const GmLogCategory &logger) |
| Saves the current state for the requested id, creating a new current state. | |
| virtual int | numNodeValueStates (QString id) const |
| Returns the number of existing states for the requested id or -1 if the id doesn't exists. | |
| virtual QString | nodeValueStateTag (QString id, int snum) const |
| Returns the state tag attached to the requested state of the named value or "" if the id doesn't exists. | |
| virtual double | nodeValueStateTime (QString id, int snum) const |
| Returns the time tag attached to the requested state of the named value or -1 if the id doesn't exists. | |
| virtual void | setNodeValueStateTag (QString id, int snum, QString tag) |
| Sets a tag name for the requested state of the named value. Does nothing if the id doesn't exists. | |
| virtual void | setNodeValueStateTime (QString id, int snum, double time) |
| Sets a time tag for the requested state of the named value. Does nothing if the id doesn't exists. | |
| virtual int | addNodes (int numNodes) |
| Adds numNodes to the mesh, WHITHOUT initializing their coordinates or attributes. | |
| virtual int | addGhostNodes (int numNodes) |
| Similar to addNodes, this function adds ghost nodes to the mesh, WHITHOUT initializing their coordinates or attributes. This function should be reimplemented by mesh implementations that support ghost nodes (hasCapability("ghostNodes") returns true). | |
| virtual void | clear () |
| Clears mesh nodes (and cells + other mesh related information depending on the concrete mesh type) if the mesh supports this operation (hasCapability("clear") returns true). | |
| QMap< QString, GmPhysicsUserFunctions * > & | userFunctionsObjMap () const |
| Returns the mesh map storing physics user function objects. | |
| virtual void | printParameters (const GmLogCategory &logger) |
| Asks the mesh to print all of its parameters using the provided logger. | |
| virtual void | printValues (const GmLogCategory &logger, int options=GM_PRINT_DEFAULT) |
| Asks the mesh to print all of its node and cell data using the provided logger and requested options. | |
| virtual size_t | nodeMemory () const =0 |
| Returns the approximate memory used for storing mesh nodes (does not include memory for s.v./attributes) | |
| virtual size_t | nodeSetsMemory () const =0 |
| Returns the approximate memory used for storing node sets. | |
| virtual GmPCR * | pcrObject () const =0 |
| Returns the PCR(Partition - Color - Renumber) object associated with this mesh. Should NEVER return NULL. If no PCR plugin object has been explicitely associated with the mesh by the user, or implicitely associated by default configuration options, a default object with no partition, coloring or renumbering MUST be returned. This default object is useful to keep code simple, without unnecessary conditions. | |
| GmValueSetGroup * | nodeValueSetGroup () const |
| Returns the ValueSetGroup object used to store the set of mesh node value sets. This is a very specialized function. Use only if you know what you are doing... | |
| GmValueSet * | nodeValueSet (QString id) const |
| Returns the node value set associated with the given cell attribute. Might be NULL. See comments for nodeValueSetGroup() | |
| GmValueSetGroup * | ghostNodeValueSetGroup () const |
| Returns the ValueSetGroup object used to store the set of mesh ghost node value sets. This is a very specialized function. Use only if you know what you are doing... | |
| GmValueSet * | ghostNodeValueSet (QString id) const |
| Returns the ghost node value set associated with the given cell attribute. Might be NULL. See comments for ghostNodeValueSetGroup() | |
| virtual void | emitMeshChanged () |
| Emmits the signal meshChanged to signal other objects that the mesh has changed. Should be called by other processes after editions to the mesh like adding new nodes / cells or changing cell geometry. | |
 Public Member Functions inherited from QObject | |
| virtual const QMetaObject * | metaObject () const const |
| QObject (QObject *parent) | |
| virtual bool | event (QEvent *e) |
| virtual bool | eventFilter (QObject *watched, QEvent *event) |
| QString | objectName () const const |
| void | setObjectName (const QString &name) |
| bool | isWidgetType () const const |
| bool | isWindowType () const const |
| bool | signalsBlocked () const const |
| bool | blockSignals (bool block) |
| QThread * | thread () const const |
| void | moveToThread (QThread *targetThread) |
| int | startTimer (int interval, Qt::TimerType timerType) |
| int | startTimer (std::chrono::milliseconds time, Qt::TimerType timerType) |
| void | killTimer (int id) |
| T | findChild (const QString &name, Qt::FindChildOptions options) const const |
| QList< T > | findChildren (const QString &name, Qt::FindChildOptions options) const const |
| QList< T > | findChildren (const QRegExp ®Exp, Qt::FindChildOptions options) const const |
| QList< T > | findChildren (const QRegularExpression &re, Qt::FindChildOptions options) const const |
| const QObjectList & | children () const const |
| void | setParent (QObject *parent) |
| void | installEventFilter (QObject *filterObj) |
| void | removeEventFilter (QObject *obj) |
| QMetaObject::Connection | connect (const QObject *sender, const char *signal, const char *method, Qt::ConnectionType type) const const |
| bool | disconnect (const char *signal, const QObject *receiver, const char *method) const const |
| bool | disconnect (const QObject *receiver, const char *method) const const |
| void | dumpObjectTree () |
| void | dumpObjectInfo () |
| void | dumpObjectTree () const const |
| void | dumpObjectInfo () const const |
| bool | setProperty (const char *name, const QVariant &value) |
| QVariant | property (const char *name) const const |
| QList< QByteArray > | dynamicPropertyNames () const const |
| void | destroyed (QObject *obj) |
| void | objectNameChanged (const QString &objectName) |
| QObject * | parent () const const |
| bool | inherits (const char *className) const const |
| void | deleteLater () |
| Q_DISABLE_COPY (Class) | |
| Q_DISABLE_MOVE (Class) | |
| Q_DISABLE_COPY_MOVE (Class) | |
| T | qobject_cast (QObject *object) |
| T | qobject_cast (const QObject *object) |
| T | qFindChild (const QObject *obj, const QString &name) |
| QList< T > | qFindChildren (const QObject *obj, const QString &name) |
| QList< T > | qFindChildren (const QObject *obj, const QRegExp ®Exp) |
| Q_CLASSINFO (Name, Value) | |
| Q_INTERFACES (...) | |
| Q_PROPERTY (...) | |
| Q_ENUMS (...) | |
| Q_FLAGS (...) | |
| Q_ENUM (...) | |
| Q_FLAG (...) | |
| Q_ENUM_NS (...) | |
| Q_FLAG_NS (...) | |
| Q_OBJECT Q_OBJECT | |
| Q_GADGET Q_GADGET | |
| Q_NAMESPACE Q_NAMESPACE | |
| Q_NAMESPACE_EXPORT (EXPORT_MACRO) | |
| Q_SIGNALS Q_SIGNALS | |
| Q_SIGNAL Q_SIGNAL | |
| Q_SLOTS Q_SLOTS | |
| Q_SLOT Q_SLOT | |
| Q_EMIT Q_EMIT | |
| Q_INVOKABLE Q_INVOKABLE | |
| Q_REVISION Q_REVISION | |
| Q_SET_OBJECT_NAME (Object) | |
| QT_NO_NARROWING_CONVERSIONS_IN_CONNECT QT_NO_NARROWING_CONVERSIONS_IN_CONNECT | |
| Public Member Functions inherited from GmPluginObject | |
| GmPluginObject (GmSimulationData *simulation, QString id, QString description, const GmLogCategory &logger) | |
| Constructor. | |
| virtual | ~GmPluginObject () |
| Destructor. | |
| QString | id () const |
| Returns the object id. | |
| QString | description () const |
| Returns the object description. | |
| QString | pluginTypeName () const |
| Returns the hierarchical type name for the plugin object type. See also pluginName() and pluginType(). | |
| virtual const char * | pluginName () const =0 |
| Returns a string identifying the plugin which implements this object. Should return the SAME string as the one read from the plugin information file in the pluginName field. | |
| virtual const char * | pluginType () const =0 |
| Returns the string identifying the plugin object type. Should return the SAME string as the one read from the plugin information file in the objectTypes table. | |
| virtual bool | loadPrivateData (LuaTable &table)=0 |
| Function called by the model loader to give the object acess to it's private parameters. Should return false only if the received parameter set makes the use of this object impossible. | |
| Public Member Functions inherited from GmGroupDumpItem | |
| virtual | ~GmGroupDumpItem () |
| Virtual destructor. | |
| virtual bool | stateAboutToBeSaved (GmStateDump *state) |
| Virtual method called just before starting a save operation on the given state. Returning false aborts the operation. | |
| virtual bool | stateSaved (GmStateDump *state) |
| Virtual method called just after succesfully completing a save operation on the given state. Returning false aborts the operation. | |
| virtual bool | stateAboutToBeLoaded (GmStateDump *state) |
| Virtual method called just before starting a load operation on the given state. Returning false aborts the operation. | |
| virtual bool | stateLoaded (GmStateDump *state) |
| Virtual method called just after succesfully completing a load operation on the given state. Returning false aborts the operation. | |
Static Public Member Functions | |
| static bool | isGhostNode (int nodeIndex) |
| Returns true if the given index is a ghost node index, false if not. | |
| static int | setGhostFlag (int nodeIndex) |
| Returns the given index with the ghost node bit set. | |
| static int | clearGhostFlag (int nodeIndex) |
| Returns the given index with the ghost node bit cleared. | |
| Static Public Member Functions inherited from QObject | |
| QString | tr (const char *sourceText, const char *disambiguation, int n) |
| QString | trUtf8 (const char *sourceText, const char *disambiguation, int n) |
| QMetaObject::Connection | connect (const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type) |
| QMetaObject::Connection | connect (const QObject *sender, const QMetaMethod &signal, const QObject *receiver, const QMetaMethod &method, Qt::ConnectionType type) |
| QMetaObject::Connection | connect (const QObject *sender, PointerToMemberFunction signal, const QObject *receiver, PointerToMemberFunction method, Qt::ConnectionType type) |
| QMetaObject::Connection | connect (const QObject *sender, PointerToMemberFunction signal, Functor functor) |
| QMetaObject::Connection | connect (const QObject *sender, PointerToMemberFunction signal, const QObject *context, Functor functor, Qt::ConnectionType type) |
| bool | disconnect (const QObject *sender, const char *signal, const QObject *receiver, const char *method) |
| bool | disconnect (const QObject *sender, const QMetaMethod &signal, const QObject *receiver, const QMetaMethod &method) |
| bool | disconnect (const QMetaObject::Connection &connection) |
| bool | disconnect (const QObject *sender, PointerToMemberFunction signal, const QObject *receiver, PointerToMemberFunction method) |
Protected Member Functions | |
| GmValueSet * | anyVsFromId (QString id) const |
| Helper function that, given an id, returns the node value set for that id if it exists. Otherwise returns the ghost value set for that id(which may also be NULL for an invalid id). | |
| void | printValueInfo (const GmLogCategory &logger, QString title, const QStringList &idList) |
| Auxiliary function to print information about state variables or attributes. | |
| virtual bool | addStateItemsToGroup (GmStateDump *state, int groupId) |
| Adds to 'state' a data item storing a control map, followed by geometry data filled by addStateGeometryData(), followed by mesh attribute data filled by addStateAccessorData(). All the items are added to the given group. Returns true on success or false on error. | |
| virtual int | controlMapStateItemType () |
| Virtual function that needs to be implemented by concrete implementation classes supporting the stateDump capability. It should return a dump type that identifies the mesh implementation. | |
| virtual bool | addStateGeometryData (GmStateDump *state, int groupId) |
| Virtual function that needs to be implemented by concrete implementation classes supporting the stateDump capability. It should add the needed additional items to the state. Keep in mind that some of the needed control data can be added/loaded from the control map, already added to the state by the standard implementation of addStateItemsToGroup(), through the fillDumpControlMapData() / dumpControlMapDataLoaded() pair of functions. | |
| virtual bool | addStateAccessorData (GmStateDump *state, int groupId) |
| Adds to 'state' accessors for all the data stored on state variables or node attributes associated with this mesh. This includes all histories. Returns true on success or false on error. | |
| virtual bool | fillDumpControlMapData (QVariantMap *map, const GmLogCategory &logger) |
| Fills the dump control data map with mesh data prior to a save operation On errors, should return false and report the error through the provided state dump logger. | |
| virtual bool | dumpControlMapDataLoaded (QVariantMap *map, const GmLogCategory &logger) |
| Sanity checks + processing of the dump control data map after a load operation. | |
| Protected Member Functions inherited from QObject | |
| QObject * | sender () const const |
| int | senderSignalIndex () const const |
| int | receivers (const char *signal) const const |
| bool | isSignalConnected (const QMetaMethod &signal) const const |
| virtual void | timerEvent (QTimerEvent *event) |
| virtual void | childEvent (QChildEvent *event) |
| virtual void | customEvent (QEvent *event) |
| virtual void | connectNotify (const QMetaMethod &signal) |
| virtual void | disconnectNotify (const QMetaMethod &signal) |
| Protected Member Functions inherited from GmPluginObject | |
| virtual const GmLogCategory & | logger () const |
| Returns the internal logger used by the plugin to emmit messages. | |
| GmSimulationData * | simulationData () const |
| Returns a reference to the simulation data object keeping global simulation information. | |
Protected Attributes | |
| int | _stateDumpControlMapItem |
| The dump item index for the control map. Used to make sure that there are no mesh data accessors prior to the map on the state. | |
Private Attributes | |
| GmValueSetGroup * | _nodeValuesGroup |
| Value set Group with node attributes / state vars data. Might have NULL entries. Size equal to _ghostNodeValuesGroup. | |
| GmValueSetGroup * | _ghostNodeValuesGroup |
| Value set Group with ghost node attributes / state vars data. Might have NULL entries. Size equal to _nodeValuesGroup. | |
| QMap< QString, GmPhysicsUserFunctions * > | _cUserFuncObjMap |
| A map storing physics user function objects indexed by the name of the plugin implementing the object. | |
| QVariantMap | _stateDumpControlMap |
| Variant map used for state dumping. | |
Additional Inherited Members | |
| Public Types inherited from QObject | |
| typedef | QObjectList |
| Properties inherited from QObject | |
| objectName | |
Base interface class for Mesh type plugins.
This Mesh interface is a simple one that supports handling of nodes and its associated attributes and/or state variables. It must be implemented by every physical mesh object exported by mesh type plugins.
The use of abstract interfaces allow for the concrete implementations to have complete control of how the node data is stored in memory (by node data we mean coordinates, attributes and state variables).
Altough this is true, most implementations will store attribute and state variable data as continuous arrays. Also, the mesh must be able to add storage space for new attributes / state variables even if the underlying mesh implementation, done by the plugin, does not support this (the mesh can obtain its data from a pre-existing read-only structure, for example).
Considering this scenario, the Mesh interface is not a pure virtual one. The default implementation manages to store a map of attributes and state variables, which are generalised in the concept of a node value, each implemented as a GmValueSet. A new attribute / state var can be added by a call to addNodeValueSet(), and that method can be used by a physics who wants to add a new attribute to a mesh or by the concrete mesh implementation to add its original attributes and state variables. Values should be later filled with the use of an accessor, as published by the mesh interface.
By using this infrastructure, the underlying concrete mesh implementation can easily handle attributes that can be scalar, vector or matrices, with their values given by constants or by functions, as implemented by GmValueSet. The only prerequisite is that attributes should be added after the number of nodes is known.
If, on the other hand, the mesh wants to have full control of how attributes are stored in memory, they can override the full set of virtual functions handling attributes. In that case, just keep in mind that support for adding new attributes / state variables is required, even if that cannot be handled by the plugin mesh itself (which can easily be handle by using the original basic functions in that case)
Node coordinates are also accessed by means of a specialized value accessor that returns node coordinates for each node as a vector. Meta data describing the number of dimensions and representation unit for each coordinate can be obtained by means of an GmValueInfo object bound to the coordinates.
| GmMesh::GmMesh | ( | GmSimulationData * | simulation, |
| QString | id, | ||
| QString | description, | ||
| const GmLogCategory & | logger ) |
Constructor.
| simulation | Reference to the simulation object. |
| id | Mesh id. |
| description | Mesh description. |
| logger | Plugin logger object used to emmit messages |
|
inlinevirtual |
Similar to addNodes, this function adds ghost nodes to the mesh, WHITHOUT initializing their coordinates or attributes. This function should be reimplemented by mesh implementations that support ghost nodes (hasCapability("ghostNodes") returns true).
On error, this function should leave the mesh unchanged and return -1. If called with numNodes equal to 0, it should return -2. On success, it should return the index of the first new node. The returned index is a value that varies from 0 to numGhostNodes() - 1 (This function does NOT returns indices with the highest bit set since that would conflict with the negative values used on error).
Please read the documentation of addNodes() for additional details.
|
inlinevirtual |
Adds numNodes to the mesh, WHITHOUT initializing their coordinates or attributes.
This function should be reimplemented by mesh implementations that support mesh edition (hasCapability("addNodes") returns true). It should increase the space for nodes by 'numNodes' new entries. Node coordinates will be later filled by the USER with a node coordinate accessor. If the mesh has attributes and state vars, this function should also make sure that those value sets are redimensioned and the new values initialised with value defaults.
On error, this function should leave the mesh unchanged and return -1. On success, it should return the index of the first new node. If called with numNodes equal to 0, it should return -2.
IMPORTANT: This function might invalidate any data pointer returned by previous accessors. The accessor themselves remain valid, but any pointers returned by calls to value() / other functions might become invalid.
IMPORTANT 2: Users of this function should call emitMeshChanged() after changes to the mesh are completed. That allows for other objects that depend on mesh number of nodes and cell geometry to respond to the changes. The FEM assembler is an example of such object.
|
virtual |
Creates a new value set for storing data associated with the metadata information received as a parameter.
The new value set takes ownership of the info object. It should be noted that info MUST have kind equal to GM_NODE_ATTRIBUTE or GM_NODE_STATEVAR.
If this function is being called during mesh loading / initialization, the added attribute will only be available for value filling through an accessor after the call to initNodeValueSets(), which should be made AFTER the mesh already knows its number of nodes.
When called after attribute initialization, the new attribute will be imediately initialized with the correct size and will be ready for filling, unless the call is inside a beginAddingNodeAttributeSets() / endAddingNodeAttributeSets call block. In that later case, the new attribute size initialization is delayed untill the end call. This allows for the addition of several attributes to a new or existing "interleaved pack" in a much more efficient way.
The function returns false in case of errors (memory could not be allocated, or the mesh already has a node attribute with the requested id, for example). In that case, info is NOT deallocated by addNodeValueSet().
|
protectedvirtual |
Adds to 'state' accessors for all the data stored on state variables or node attributes associated with this mesh. This includes all histories. Returns true on success or false on error.
Reimplemented in GmCellMesh, and GmElementMesh.
|
protectedvirtual |
Adds to 'state' a data item storing a control map, followed by geometry data filled by addStateGeometryData(), followed by mesh attribute data filled by addStateAccessorData(). All the items are added to the given group. Returns true on success or false on error.
This ordering ensures that the control data is loaded first, followed by the geometry data and only then by mesh data stored through accessors. Keep in mind that when restoring value sets it is necessary that the mesh geometry is already loaded.
Auxiliar variant map dump item that notifies the mesh for loading and saving data to the map
< Our "father" mesh object
Implements GmGroupDumpItem.
|
inlinevirtual |
Clears mesh nodes (and cells + other mesh related information depending on the concrete mesh type) if the mesh supports this operation (hasCapability("clear") returns true).
Keep in mind that this function does not remove the set of state vars or attributes added to the mesh, although it clears its stored values.
|
protectedvirtual |
Sanity checks + processing of the dump control data map after a load operation.
Reimplemented in GmCellMesh, and GmElementMesh.
|
protectedvirtual |
Fills the dump control data map with mesh data prior to a save operation On errors, should return false and report the error through the provided state dump logger.
Reimplemented in GmCellMesh, and GmElementMesh.
|
inline |
Returns the ValueSetGroup object used to store the set of mesh ghost node value sets. This is a very specialized function. Use only if you know what you are doing...
The returned group will contain value sets for state vars and attributes with node data storage equal to GM_GHOST_NODE or GM_BOTH. It does NOT include GM_GEOMETRY_NODE value sets. Also keep in mind that the value sets with GM_BOTH included in this group are different from the ones in the group returned by nodeValueSetGroup(), storing data only for the ghost nodes part.
IMPORTANT: The returned group might contain NULL entries.
IMPORTANT 2: The returned group contains the value sets stored by the base mesh implementation. Concrete mesh classes are free not to use this mechanism to store all of their data, so implementations that can be handling with any kind of mesh plugins should refrain from using this function.
|
pure virtual |
This function should return true or false to indicate whether the mesh implementation supports the requested capability or not. Capabilities are refered by string names in order to enable derived interfaces to extend the available capabilities that can be queried.
Standard capability names: addNodes - Does the mesh support adding new nodes? addCells - Does the mesh support adding new cells? topology - Does the mesh support topological queries? ghostNodes - Does the mesh support adding/removing ghost nodes? editGroups - Does the mesh support adding cell groups and adding cells to groups? clear - Does the mesh support clearing (removing) all nodes and cells and later addition of new ones? stateDump - Does the mesh support state dumping and restoring for restart operations?
|
inlinestatic |
Returns true if the given index is a ghost node index, false if not.
Ghost node indices are values that vary from 0 to numGhostNodes() - 1 WITH their high bit SET in order to make a distinction between common indices and ghost node indices.
That means that, for example, the first two ghost nodes have, respectively, an index equal to 0x80000000 and 0x80000001 if node indexes are stored in 32 bit integers. Also notice that -1 is equal to 0xFFFFFFFF and so we can "safelly" have methods that return -1 on errors, even when the return can be a ghost node (supposing that we have less than 2 billion ghost nodes in he mesh - we would probably have many other problems if that limit is ever reached).
|
pure virtual |
Returns an accessor object used to access node coordinates.
The logger parameter exists to allow for the accessor to use a different logger than the mesh one to report errors. For example, in an analysis context it might be interesting to report errors through the physics plugin logger instead of by the mesh logger.
|
virtual |
Creates an accessor object for the state var associated with the requested degree of freedom number. Returns NULL if the dof number is invalid or if that state var is not associated with this mesh.
For state vars that store vector values, the state var can be recognized by any value in the range covered by its base dof and the next 'n-1' values where 'n' is the vector size.
If stateVar is different from NULL, returns the state var.
IMPORTANT: To recover an accessor for a state var with known id, it's much better to call nodeValueAccessor(). This is not a fast function since there are no special indices to find a state var from its dof number (but that really should not be a problem unless you have hundreds of state vars or if you need to call this in a thight lopp, which you shouldn't any way).
If desiredUnit is a known unit, different from the basic node value unit, the value will be automatically converted to the desired unit. If no conversion is possible, the function returns NULL. To avoid conversions, just pass Unit() as the desiredUnit.
IMPORTANT 2: The returned accessor should be deallocated by the caller.
|
virtual |
Overloads nodeValueAccessor(QString, Unit, ...) to return an accessor for the requested previous state of a value.
The snum parameter contains the requested state. A value of zero means the current state, 1 the previous one, 2 the one before that and so on. Valid values range from zero to the oldest state for the requested variable, which can be queried with a call to numNodeValueStates(). Remember that for a value accessor to support states, the history parameter must be set in its value info object.
The locked parameter control the behaviour of the accessor once a new state is created for the value. The 'lock' refers to the state number, so if locked is false and a new state is created, the accessor doesn't change and continues to point to the same data. If locked is true, the accessor will be locked to that state number so when a new state is created, the accessor changes the data its looking upon to reflect the new state. For example, an accessor locked on the state 0 will always point to the current state and one locked to the state 1 will always point to the previous saved value.
See the overloaded function for the remaining parameters.
|
virtual |
Creates an accessor object for the values (attribute / state var) associated with the value id.
Remember that node attributes and state vars should have unique ids among themselves. If the id does not refer to a known attribute / state var, returns NULL.
If desiredUnit is a known unit, different from the basic node value unit, the value will be automatically converted to the desired unit. If no conversion is possible, the function returns NULL. To avoid conversions, just pass Unit() as the desiredUnit.
The logger parameter exists to allow for the accessor to use a different logger than the mesh one to report errors. For example, in an analysis context it might be interesting to report errors through the physics plugin logger instead of by the mesh logger.
IMPORTANT: The returned accessor should be deallocated by the caller.
Obs: This is equivalent to calling nodeValueAccessor(id, 0, true, desiredUnit, logger)
|
virtual |
Returns the metadata describing the values (attribute / state var) associated with the value id.
Remember that node attributes and state vars should have unique ids among themselves. If the id does not refer to a known attribute / state var, returns NULL.
If filter != -1, it should be one of GM_NODE_ATTRIBUTE or GM_NODE_STATEVAR and defines that the return value should be NULL if a matching value does not have the specified type.
|
inline |
Returns the ValueSetGroup object used to store the set of mesh node value sets. This is a very specialized function. Use only if you know what you are doing...
The returned group will contain value sets for state vars and attributes with node data storage equal to GM_GEOMETRY_NODE or GM_BOTH. It does NOT include GM_GHOST_NODE value sets. Also keep in mind that the value sets with GM_BOTH included in this group are different from the ones in the group returned by ghostNodeValueSetGroup(), storing data only for the common nodes part.
IMPORTANT: The returned group might contain NULL entries. Although strange, allowing this makes the GmMesh implementation easier.
IMPORTANT 2: The returned group contains the value sets stored by the base mesh implementation. Concrete mesh classes are free not to use this mechanism to store all of their data, so implementations that can be handling with any kind of mesh plugins should refrain from using this function.
|
inlinevirtual |
Returns the plugin category.
Implements GmPluginObject.
|
virtual |
Asks the mesh to print all of its parameters using the provided logger.
The default implementation logs the data, as seen through the access interface. Restricting ourselves to the published interface allows this function to work well even if the concrete mesh plugin reimplements completely the attribute / state vars system
Implements GmPluginObject.
Reimplemented in GmCellMesh, and GmElementMesh.
|
virtual |
Asks the mesh to print all of its node and cell data using the provided logger and requested options.
The default implementation logs the node data, as seen through the access interface. The options parameter should be an 'or' of GmPrintUtilsFlags entries.
Reimplemented in GmCellMesh, and GmElementMesh.
|
pure virtual |
Pushes a proxy object for the current mesh onto the Lua stack.
The proxy object should be a sub class of GmLuaMesh and can include specific functions not in the standard mesh interfaces. This interface is based on pushing the object on the Lua stack and not by returning a GmLuaMesh object since the later option would create a circular dependency between the GemaCore library and the GemaLuaCore library.
|
virtual |
Saves the current state for the requested id, creating a new current state.
If the value does not supports history values, does nothing, returning false. The mode parameter defines how the new state will be initialized (with a copy of the old one, with the value default or uninitialized).
The time associated with the new current state is initialized to the value of the current time as seen from the simulation data object. This can later be changed by a call to setNodeValueStateTime().
Returns true if the state was created successfully, false otherwise.
|
virtual |
Simmilar to saveNodeValueState(), saves the current state of all values that support state saving. See saveNodeValueState() for more details.
Reimplemented in GmCellMesh, and GmElementMesh.
|
inline |
If nodeIndex is a value with its high bit set, returns the index (high bit cleared)
|
pure virtual |
Returns true if the mesh data is stored in a "dual" vector, instead of a single one.
The dual vector policy separates the data into a initial set and a "growing" set for later added values. This can be interesting for dynamic meshes where new nodes / cells are added often during the simulation, but still representing a small fraction of the mesh size. With the Dual vector policy, only the "growing" part is resized. The choice of which vector to use is entirely to the plugin implementation and might be based on a user setting.
|
mutableprivate |
A map storing physics user function objects indexed by the name of the plugin implementing the object.
When a C user function is attached to the mesh (by a node/cell attribute or property) an object created by the plugin that implements the c function is instanced and associated to the mesh. If a plugin exports more than one function attached to the same mesh, the same object is shared between the functions.
The map owns the physics objects that will be deleted when the mesh is destroyed. Marked as mutable since the map is filled in a lazy way when evaluating user functions that have a reference to a const mesh.
1.12.0